home *** CD-ROM | disk | FTP | other *** search
/ LG Super CD / LG Super CD.iso / bitpim / bitpim-0.62-setup.exe / {app} / bitpim.exe / UserDict.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2003-11-06  |  9.5 KB  |  279 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.3)
  3.  
  4.  
  5. class UserDict:
  6.     
  7.     def __init__(self, dict = None, **kwargs):
  8.         self.data = { }
  9.         if dict is not None:
  10.             if not hasattr(dict, 'keys'):
  11.                 dict = type({ })(dict)
  12.             
  13.             self.update(dict)
  14.         
  15.         if len(kwargs):
  16.             self.update(kwargs)
  17.         
  18.  
  19.     
  20.     def __repr__(self):
  21.         return repr(self.data)
  22.  
  23.     
  24.     def __cmp__(self, dict):
  25.         if isinstance(dict, UserDict):
  26.             return cmp(self.data, dict.data)
  27.         else:
  28.             return cmp(self.data, dict)
  29.  
  30.     
  31.     def __len__(self):
  32.         return len(self.data)
  33.  
  34.     
  35.     def __getitem__(self, key):
  36.         return self.data[key]
  37.  
  38.     
  39.     def __setitem__(self, key, item):
  40.         self.data[key] = item
  41.  
  42.     
  43.     def __delitem__(self, key):
  44.         del self.data[key]
  45.  
  46.     
  47.     def clear(self):
  48.         self.data.clear()
  49.  
  50.     
  51.     def copy(self):
  52.         if self.__class__ is UserDict:
  53.             return UserDict(self.data)
  54.         
  55.         import copy
  56.         data = self.data
  57.         
  58.         try:
  59.             self.data = { }
  60.             c = copy.copy(self)
  61.         finally:
  62.             self.data = data
  63.  
  64.         c.update(self)
  65.         return c
  66.  
  67.     
  68.     def keys(self):
  69.         return self.data.keys()
  70.  
  71.     
  72.     def items(self):
  73.         return self.data.items()
  74.  
  75.     
  76.     def iteritems(self):
  77.         return self.data.iteritems()
  78.  
  79.     
  80.     def iterkeys(self):
  81.         return self.data.iterkeys()
  82.  
  83.     
  84.     def itervalues(self):
  85.         return self.data.itervalues()
  86.  
  87.     
  88.     def values(self):
  89.         return self.data.values()
  90.  
  91.     
  92.     def has_key(self, key):
  93.         return self.data.has_key(key)
  94.  
  95.     
  96.     def update(self, dict):
  97.         if isinstance(dict, UserDict):
  98.             self.data.update(dict.data)
  99.         elif isinstance(dict, type(self.data)):
  100.             self.data.update(dict)
  101.         else:
  102.             for k, v in dict.items():
  103.                 self[k] = v
  104.             
  105.  
  106.     
  107.     def get(self, key, failobj = None):
  108.         if not self.has_key(key):
  109.             return failobj
  110.         
  111.         return self[key]
  112.  
  113.     
  114.     def setdefault(self, key, failobj = None):
  115.         if not self.has_key(key):
  116.             self[key] = failobj
  117.         
  118.         return self[key]
  119.  
  120.     
  121.     def pop(self, key, *args):
  122.         return self.data.pop(key, *args)
  123.  
  124.     
  125.     def popitem(self):
  126.         return self.data.popitem()
  127.  
  128.     
  129.     def __contains__(self, key):
  130.         return key in self.data
  131.  
  132.     
  133.     def fromkeys(cls, iterable, value = None):
  134.         d = cls()
  135.         for key in iterable:
  136.             d[key] = value
  137.         
  138.         return d
  139.  
  140.     fromkeys = classmethod(fromkeys)
  141.  
  142.  
  143. class IterableUserDict(UserDict):
  144.     
  145.     def __iter__(self):
  146.         return iter(self.data)
  147.  
  148.  
  149.  
  150. class DictMixin:
  151.     
  152.     def __iter__(self):
  153.         for k in self.keys():
  154.             yield k
  155.         
  156.  
  157.     
  158.     def has_key(self, key):
  159.         
  160.         try:
  161.             value = self[key]
  162.         except KeyError:
  163.             return False
  164.  
  165.         return True
  166.  
  167.     
  168.     def __contains__(self, key):
  169.         return self.has_key(key)
  170.  
  171.     
  172.     def iteritems(self):
  173.         for k in self:
  174.             yield (k, self[k])
  175.         
  176.  
  177.     
  178.     def iterkeys(self):
  179.         return self.__iter__()
  180.  
  181.     
  182.     def itervalues(self):
  183.         for _, v in self.iteritems():
  184.             yield v
  185.         
  186.  
  187.     
  188.     def values(self):
  189.         return [ v for _, v in self.iteritems() ]
  190.  
  191.     
  192.     def items(self):
  193.         return list(self.iteritems())
  194.  
  195.     
  196.     def clear(self):
  197.         for key in self.keys():
  198.             del self[key]
  199.         
  200.  
  201.     
  202.     def setdefault(self, key, default):
  203.         
  204.         try:
  205.             return self[key]
  206.         except KeyError:
  207.             self[key] = default
  208.  
  209.         return default
  210.  
  211.     
  212.     def pop(self, key, *args):
  213.         if len(args) > 1:
  214.             raise TypeError, 'pop expected at most 2 arguments, got ' + repr(1 + len(args))
  215.         
  216.         
  217.         try:
  218.             value = self[key]
  219.         except KeyError:
  220.             if args:
  221.                 return args[0]
  222.             
  223.             raise 
  224.  
  225.         del self[key]
  226.         return value
  227.  
  228.     
  229.     def popitem(self):
  230.         
  231.         try:
  232.             (k, v) = self.iteritems().next()
  233.         except StopIteration:
  234.             raise KeyError, 'container is empty'
  235.  
  236.         del self[k]
  237.         return (k, v)
  238.  
  239.     
  240.     def update(self, other):
  241.         if hasattr(other, 'iteritems'):
  242.             for k, v in other.iteritems():
  243.                 self[k] = v
  244.             
  245.         elif hasattr(other, '__iter__'):
  246.             for k in other:
  247.                 self[k] = other[k]
  248.             
  249.         else:
  250.             for k in other.keys():
  251.                 self[k] = other[k]
  252.             
  253.  
  254.     
  255.     def get(self, key, default = None):
  256.         
  257.         try:
  258.             return self[key]
  259.         except KeyError:
  260.             return default
  261.  
  262.  
  263.     
  264.     def __repr__(self):
  265.         return repr(dict(self.iteritems()))
  266.  
  267.     
  268.     def __cmp__(self, other):
  269.         if isinstance(other, DictMixin):
  270.             other = dict(other.iteritems())
  271.         
  272.         return cmp(dict(self.iteritems()), other)
  273.  
  274.     
  275.     def __len__(self):
  276.         return len(self.keys())
  277.  
  278.  
  279.